home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1995 April / Internet Tools.iso / osi / isode / dosisode / DOSISODE80.ZIP / ISODE8.WRK / ROSY / LEX.C_N next >
Encoding:
Text File  |  1992-06-28  |  21.6 KB  |  1,033 lines
  1. # include "stdio.h"
  2. # define U(x) x
  3. # define NLSTATE yyprevious=YYNEWLINE
  4. # define BEGIN yybgin = yysvec + 1 +
  5. # define INITIAL 0
  6. # define YYLERR yysvec
  7. # define YYSTATE (yyestate-yysvec-1)
  8. # define YYOPTIM 1
  9. # define YYLMAX BUFSIZ
  10. # define output(c) putc(c,yyout)
  11. # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  12. # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  13. # define yymore() (yymorfg=1)
  14. # define ECHO fprintf(yyout, "%s",yytext)
  15. # define REJECT { nstr = yyreject(); goto yyfussy;}
  16. int yyleng; extern char yytext[];
  17. int yymorfg;
  18. extern char *yysptr, yysbuf[];
  19. int yytchar;
  20. FILE *yyin = {stdin}, *yyout = {stdout};
  21. extern int yylineno;
  22. struct yysvf { 
  23.     struct yywork *yystoff;
  24.     struct yysvf *yyother;
  25.     int *yystops;};
  26. struct yysvf *yyestate;
  27. extern struct yysvf yysvec[], *yybgin;
  28. #ifndef    lint
  29. static char *RCSid = "$Header: /xtel/isode/isode/pepy/RCS/lex.l.gnrc,v 9.0 1992/06/16 12:25:01 isode Rel $";
  30. #endif
  31.  
  32. /* 
  33.  * $Header: /xtel/isode/isode/pepy/RCS/lex.l.gnrc,v 9.0 1992/06/16 12:25:01 isode Rel $
  34.  *
  35.  *
  36.  * $Log: lex.l.gnrc,v $
  37.  * Revision 9.0  1992/06/16  12:25:01  isode
  38.  * Release 8.0
  39.  *
  40.  */
  41.  
  42. /*
  43.  *                  NOTICE
  44.  *
  45.  *    Acquisition, use, and distribution of this module and related
  46.  *    materials are subject to the restrictions of a license agreement.
  47.  *    Consult the Preface in the User's Manual for the full terms of
  48.  *    this agreement.
  49.  *
  50.  *
  51.  */
  52.  
  53.  
  54. struct table {
  55.     char   *t_keyword;
  56.     int        t_value;
  57.     int        t_porting;
  58. };
  59.  
  60. static struct table reserved[] = {
  61.     "ABSENT", ABSENT, 0,
  62.     "ANY", ANY, 0,
  63.     "APPLICATION", APPLICATION, 0,
  64.     "BEGIN", BGIN, 0,
  65.     "BIT", BIT, 0,
  66.     "BITSTRING", BITSTRING, 0,
  67.     "BOOLEAN", BOOLEAN, 0,
  68.     "BY", BY, 0,
  69.     "CHOICE", CHOICE, 0,
  70.     "COMPONENT", COMPONENT, 0,
  71.     "COMPONENTS", COMPONENTS, 0,
  72.     "COMPONENTSOF", COMPONENTSOF, 0,
  73.     "DECODER", DECODER, 0,
  74.     "DEFAULT", DEFAULT, 0,
  75.     "DEFINED", DEFINED, 0,
  76.     "DEFINITIONS", DEFINITIONS, 0,
  77.     "ENCODER", ENCODER, 0,
  78.     "ENCRYPTED", ENCRYPTED, 0,
  79.     "END", END, 0,
  80.     "ENUMERATED", ENUMERATED, 0,
  81.     "EXPLICIT", EXPLICIT, 0,
  82.     "EXPORTS", EXPORTS, 0,
  83.     "FALSE", L_FALSE, 0,
  84.     "FROM", FROM, 0,
  85.     "IDENTIFIER", IDENTIFIER, 0,
  86.     "IMPLICIT", IMPLICIT, 0,
  87.     "IMPORTS", IMPORTS, 0,
  88.     "INCLUDE", INCLUDES, 0,
  89.     "INTEGER", INTEGER, 0,
  90.     "MIN", MIN, 0,
  91.     "MAX", MAX, 0,
  92.     "NULL", NIL, 0,
  93.     "OBJECT", OBJECT, 0,
  94.     "OCTET", OCTET, 0,
  95.     "OCTETSTRING", OCTETSTRING, 0,
  96.     "OF", OF, 0,
  97.     "OPTIONAL", OPTIONAL, 0,
  98.     "PREFIXES", PREFIXES, 0,
  99.     "PRESENT", PRESENT, 0,
  100.     "PRINTER", PRINTER, 0,
  101.     "PRIVATE", PRIVATE, 0,
  102.     "REAL", REAL, 0,
  103.     "SECTIONS", SECTIONS, 0,
  104.     "SEQUENCE", SEQUENCE, 0,
  105.     "SEQUENCEOF", SEQUENCEOF, 0,
  106.     "SET", SET, 0,
  107.     "SETOF", SETOF, 0,
  108.     "SIZE", SIZE, 0,
  109.     "STRING", STRING, 0,
  110.     "TAGS", TAGS, 0,
  111.     "TRUE", L_TRUE, 0,
  112.     "UNIVERSAL", UNIVERSAL, 0,
  113.     "WITH", WITH, 0,
  114.     "PLUS-INFINITY", PLUSINFINITY, 0,
  115.     "MINUS-INFINITY", MINUSINFINITY, 0,
  116.     "OPERATION", OPERATION, 1,
  117.     "ARGUMENT", ARGUMENT, 0,
  118.     "RESULT", RESULT, 0,
  119.     "ERRORS", ERRORS, 0,
  120.     "LINKED", LINKED, 0,
  121.     "ERROR", ERROR, 1,
  122.     "PARAMETER", PARAMETER, 0,
  123. /* start new stuff */
  124.     "ABSTRACT-OPERATION", OPERATION, 0,
  125.     "ABSTRACT-ERROR", ERROR, 0,
  126.     "ABSTRACT", ABSTRACT, 0,
  127.     "OPERATIONS", OPERATIONS, 0,
  128.     "CONSUMER", CONSUMER, 0,
  129.     "SUPPLIER", SUPPLIER, 0,
  130.     "INVOKES", INVOKES, 0,
  131.     "PORT", PORT, 0,
  132.     "PORTS", PORTS, 0,
  133. /* refine is beyond me! (JPO)
  134.     "REFINE", REFINE, 0,
  135.     "AS", AS, 0,
  136.     "RECURRING", RECURRING, 0,
  137.     "VISIBLE", VISIBLE, 0,
  138.     "PAIRED", PAIRED, 0,
  139. */
  140. /* end new stuff */
  141.     NULL, 0
  142. };
  143. # define YYNEWLINE 10
  144. yylex(){
  145. int nstr; extern int yyprevious;
  146. while((nstr = yylook()) >= 0)
  147. yyfussy: switch(nstr){
  148. case 0:
  149. if(yywrap()) return(0); break;
  150. case 1:
  151.         {   register int c, d;
  152.  
  153.                 for (d = 0; c = input (); d = c == '-')
  154.                 if (c == '\n' || (d && c == '-'))
  155.                     break;
  156.             }
  157. break;
  158. case 2:
  159.         {
  160.                 if (yydebug)
  161.                 fprintf (stderr, "WT\n");
  162.             }
  163. break;
  164. case 3:
  165.         {
  166.                 if (yydebug)
  167.                 fprintf (stderr, "NL\n");
  168.             }
  169. break;
  170. case 4:
  171.         {
  172.                 if (yydebug)
  173.                 fprintf (stderr, "SY: CCE\n");
  174.                 return CCE;
  175.             }
  176. break;
  177. case 5:
  178.         {
  179.                 if (yydebug)
  180.                     fprintf (stderr, "SY: DOTDOTDOT\n");
  181.                 return DOTDOTDOT;
  182.             }
  183. break;
  184. case 6:
  185.         {
  186.                     if (yydebug)
  187.                 fprintf (stderr, "SY: DOTDOT\n");
  188.                 return DOTDOT;
  189.             }
  190. break;
  191. case 7:
  192.         {
  193.                 if (yydebug)
  194.                 fprintf (stderr, "SY: DOT\n");
  195.                 return DOT;
  196.             }
  197. break;
  198. case 8:
  199.         {
  200.                 if (yydebug)
  201.                 fprintf (stderr, "SY: SEMICOLON");
  202.                 return SEMICOLON;
  203.             }
  204. break;
  205. case 9:
  206.         {
  207.                 if (yydebug)
  208.                 fprintf (stderr, "SY: COMMA\n");
  209.                 return COMMA;
  210.             }
  211. break;
  212. case 10:
  213.         {
  214.                 if (yydebug)
  215.                 fprintf (stderr, "SY: LBRACE\n");
  216.                 return LBRACE;
  217.             }
  218. break;
  219. case 11:
  220.         {
  221.                 if (yydebug)
  222.                 fprintf (stderr, "SY: RBRACE\n");
  223.                 return RBRACE;
  224.             }
  225. break;
  226. case 12:
  227.         {
  228.                 if (yydebug)
  229.                 fprintf (stderr, "SY: BAR\n");
  230.                 return BAR;
  231.             }
  232. break;
  233. case 13:
  234.         {
  235.                 if (yydebug)
  236.                 fprintf (stderr, "SY: OBJECTSUPPLIER\n");
  237.                 return OBJECTSUPPLIER;
  238.             }
  239. break;
  240. case 14:
  241.         {
  242.                 if (yydebug)
  243.                 fprintf (stderr, "SY: OBJECTCONSUMER\n");
  244.                 return OBJECTCONSUMER;
  245.             }
  246. break;
  247. case 15:
  248.     {   register int tok, c, d, len;
  249.                 register char *cp, *ep, *pp;
  250.  
  251.                 if (*yytext == '$')
  252.                 tok = VLENGTH;
  253.                 else
  254.                 if (*yytext == '<')
  255.                     tok = CONTROL;
  256.                 else {
  257.                     while((c = input()) == ' ' || c =='\t')
  258.                         continue;
  259.                     switch (c) {
  260.                     case 'a': tok = VALA;
  261.                           break;
  262.                     case 'b': tok = VALB;
  263.                           break;
  264.                     case 'i': tok = VALI;
  265.                           break;
  266.                     case 's': tok = VALS;
  267.                           break;
  268.                     case 'o': tok = VALO;
  269.                           break;
  270.                     case 'x': tok = VALX;
  271.                           break;
  272.                     case 'p': tok = VALP;
  273.                           break;
  274.                     case 'q': tok = VALQ;
  275.                               break;
  276.                     case 'r': tok = VALR;
  277.                           break;
  278.                     case 'O': tok = VALOID;
  279.                           break;
  280.                     case 'P': tok = PARAMETERTYPE;
  281.                               break;
  282.                     default : myyerror ("unknown token: \"%s\"", yytext);
  283.                           break;
  284.                     }
  285.                     if ((c = input()) != ' ' && c != '\t'
  286.                     && c != '\n')
  287.                     yyerror ("syntax error in [[ ... ]]");
  288.                 }
  289.  
  290.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  291.                     == NULL)
  292.                 yyerror ("out of memory");
  293.  
  294.                 for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
  295.                 if ((c = input ()) == NULL)
  296.                     yyerror ("end-of-file while reading value");
  297.                 if ((d == ']' && c == ']' && tok !=CONTROL) ||
  298.                     (c == '$' && (tok ==VALX || tok ==VALO)) ||
  299.                     (d == '>' && c == '>' && tok ==CONTROL)) {
  300.                     if ((tok == VALX || tok == VALO) &&
  301.                        (c != '$'))
  302.                        yyerror("Missing '$' in [[ - ]]");
  303.                     if (c == '$') {unput(c); *cp = NULL;}
  304.                     else *--cp = NULL;
  305.                     yylval.yy_string = pp;
  306.                     if (yydebug)
  307.                     fprintf (stderr, "VAL: \"%s\"\n",
  308.                         yylval.yy_string);
  309.                     return tok;
  310.                 }
  311.                 if (cp >= ep) {
  312.                     register int curlen = cp - pp;
  313.                     register char *dp;
  314.  
  315.                     if ((dp = realloc (pp,
  316.                         (unsigned) (len += BUFSIZ)))
  317.                         == NULL)
  318.                     yyerror ("out of memory");
  319.                     cp = dp + curlen;
  320.                     ep = (pp = dp) + len - 1;
  321.                 }
  322.                 *cp++ = c;
  323.                 }
  324.             }
  325. break;
  326. case 16:
  327.         {
  328.                 if (yydebug)
  329.                 fprintf (stderr, "SY: LBRACKET\n");
  330.                 return LBRACKET;
  331.             }
  332. break;
  333. case 17:
  334.         {
  335.                 if (yydebug)
  336.                 fprintf (stderr, "SY: RBRACKET\n");
  337.                 return RBRACKET;
  338.             }
  339. break;
  340. case 18:
  341.         {
  342.                 if (yydebug)
  343.                 fprintf (stderr, "SY: LANGLE\n");
  344.                 return LANGLE;
  345.             }
  346. break;
  347. case 19:
  348.         {
  349.                 if (yydebug)
  350.                 fprintf (stderr, "SY: LPAREN\n");
  351.                 return LPAREN;
  352.             }
  353. break;
  354. case 20:
  355.         {
  356.                 if (yydebug)
  357.                 fprintf (stderr, "SY: RPAREN\n");
  358.                 return RPAREN;
  359.             }
  360. break;
  361. case 21:
  362.         {
  363.                 (void) sscanf (yytext, "%d", &yylval.yy_number);
  364.                 if (yydebug)
  365.                 fprintf (stderr, "LIT: 0x%x\n", yylval.yy_number);
  366.                 return LITNUMBER;
  367.             }
  368. break;
  369. case 22:
  370.         {
  371.                 (void) sscanf (yytext, "%d", &yylval.yy_number);
  372.                 if (yydebug)
  373.                 fprintf (stderr, "LIT: 0x%x\n", yylval.yy_number);
  374.                 return LITNUMBER;
  375.             }
  376. break;
  377. case 23:
  378.     {   register char *cp; register int i;
  379.  
  380.                 switch (*(cp = yytext + strlen (yytext) - 1)) {
  381.                 case 'H':
  382.                 case 'h':
  383.                     *cp = NULL;
  384.                     (void) sscanf (yytext + 1, "%x",
  385.                         &yylval.yy_number);
  386.                     break;
  387.  
  388.                 case 'B':
  389.                 case 'b':
  390.                     *cp-- = NULL, *cp = NULL;
  391.                     for (i = 0, cp = yytext + 1; *cp; ) {
  392.                     i <<= 1;
  393.                     i += *cp++ - '0';
  394.                     }
  395.                     yylval.yy_number = i;
  396.                     break; 
  397.                 }
  398.                 if (yydebug)
  399.                 fprintf (stderr, "LIT: 0x%x\n", yylval.yy_number);
  400.                 return LITNUMBER;
  401.             }
  402. break;
  403. case 24:
  404.         {
  405.                 int        c, len;
  406.                 register char *cp, *ep, *pp;
  407.  
  408.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  409.                     == NULL)
  410.                 yyerror ("out of memory");
  411.  
  412.                 for (ep = (cp = pp) + len - 1;;) {
  413.                 if ((c = input ()) == NULL)
  414.                     yyerror ("end-of-file while reading string");
  415.                 if (c == '"')
  416.                     break;
  417.  
  418.                 if (cp >= ep) {
  419.                     register int curlen = cp - pp;
  420.                     register char *dp;
  421.  
  422.                     if ((dp = realloc (pp,
  423.                                (unsigned) (len += BUFSIZ)))
  424.                         == NULL)
  425.                     yyerror ("out of memory");
  426.                     cp = dp + curlen;
  427.                     ep = (pp = dp) + len - 1;
  428.                 }
  429.                 *cp++ = c;
  430.                 }
  431.                 *cp = NULL;
  432.                 yylval.yy_string = pp;
  433.                 if (yydebug)
  434.                 fprintf (stderr, "LIT: \"%s\"\n",
  435.                      yylval.yy_string);
  436.                 return LITSTRING;
  437.             }
  438. break;
  439. case 25:
  440. {   register struct table *t;
  441.  
  442.                 for (t = reserved; t -> t_keyword; t++)
  443.                 if (strcmp (t -> t_keyword, yytext) == 0) {
  444.                     if (yyporting && t -> t_porting)
  445.                     break;
  446.                     if (yydebug)
  447.                     fprintf (stderr,
  448.                           "KE: \"%s\"\n", yytext);
  449.                     return t -> t_value;
  450.                 }
  451.                 yylval.yy_string = new_string (yytext);
  452.                 if (yydebug)
  453.                 fprintf (stderr, "ID: \"%s\"\n", yylval.yy_string);
  454.                 return ID;
  455.             }
  456. break;
  457. case 26:
  458. {   yylval.yy_string = new_string (yytext);
  459.                 if (yydebug)
  460.                 fprintf (stderr, "NAME: \"%s\"\n", yylval.yy_string);
  461.                 return NAME;
  462.             }
  463. break;
  464. case 27:
  465.         {   register int c, d, len;
  466.                 register char *cp, *ep, *pp;
  467.  
  468.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  469.                     == NULL)
  470.                 yyerror ("out of memory");
  471.  
  472.                 for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
  473.                 if ((c = input ()) == NULL)
  474.                     yyerror ("end-of-file while reading value");
  475.                 if (d == '%' && c == ']' ) {
  476.                     *--cp = NULL;
  477.                     yylval.yy_string = pp;
  478.                     if (yydebug)
  479.                     fprintf (stderr, "VAL: \"%s\"\n",
  480.                          yylval.yy_string);
  481.                     return SCTRL;
  482.                 }
  483.                 if (d == '\n')
  484.                     yyerror ("newline in %[ %] construct");
  485.                 if (cp >= ep) {
  486.                     register int curlen = cp - pp;
  487.                     register char *dp;
  488.  
  489.                     if ((dp = realloc (pp,
  490.                         (unsigned) (len += BUFSIZ)))
  491.                         == NULL)
  492.                     yyerror ("out of memory");
  493.                     cp = dp + curlen;
  494.                     ep = (pp = dp) + len - 1;
  495.                 }
  496.                 *cp++ = c;
  497.                 }
  498.             }
  499. break;
  500. case 28:
  501.         {   register int c, d, len;
  502.                 int        mylineno;
  503.                 register char *cp, *ep, *pp;
  504.  
  505.                 mylineno = yylineno;
  506.                 if ((pp = malloc ((unsigned) (len = BUFSIZ)))
  507.                     == NULL)
  508.                 yyerror ("out of memory");
  509.  
  510.                 for (ep = (cp = pp) + len - 1, d = NULL;; d = c) {
  511.                 if ((c = input ()) == NULL)
  512.                     yyerror ("end-of-file while reading action");
  513.                 if (d == '%' && c == '}') {
  514.                     *--cp = NULL;
  515.                     yylval.yy_action = new_action (pp, mylineno);;
  516.                     if (yydebug)
  517.                     fprintf (stderr, "ACTION: \"%s\", %d\n",
  518.                         yylval.yy_action -> ya_text,
  519.                         yylval.yy_action -> ya_lineno);
  520.                     return ACTION;
  521.                 }
  522.                 if (cp >= ep) {
  523.                     register int curlen = cp - pp;
  524.                     register char *dp;
  525.  
  526.                     if ((dp = realloc (pp,
  527.                         (unsigned) (len += BUFSIZ)))
  528.                         == NULL)
  529.                     yyerror ("out of memory");
  530.                     cp = dp + curlen;
  531.                     ep = (pp = dp) + len - 1;
  532.                 }
  533.                 *cp++ = c;
  534.                 }
  535.             }
  536. break;
  537. case 29:
  538.         {   
  539.                 myyerror ("unknown token: \"%s\"", yytext);
  540.             }
  541. break;
  542. case -1:
  543. break;
  544. default:
  545. fprintf(yyout,"bad switch yylook %d",nstr);
  546. } return(0); }
  547. /* end of yylex */
  548. int yyvstop[] = {
  549. 0,
  550.  
  551. 2,
  552. 0,
  553.  
  554. 2,
  555. 0,
  556.  
  557. 29,
  558. 0,
  559.  
  560. 2,
  561. 29,
  562. 0,
  563.  
  564. 3,
  565. 0,
  566.  
  567. 24,
  568. 29,
  569. 0,
  570.  
  571. 15,
  572. 29,
  573. 0,
  574.  
  575. 29,
  576. 0,
  577.  
  578. 29,
  579. 0,
  580.  
  581. 19,
  582. 29,
  583. 0,
  584.  
  585. 20,
  586. 29,
  587. 0,
  588.  
  589. 9,
  590. 29,
  591. 0,
  592.  
  593. 29,
  594. 0,
  595.  
  596. 7,
  597. 29,
  598. 0,
  599.  
  600. 21,
  601. 29,
  602. 0,
  603.  
  604. 29,
  605. 0,
  606.  
  607. 8,
  608. 29,
  609. 0,
  610.  
  611. 18,
  612. 29,
  613. 0,
  614.  
  615. 25,
  616. 29,
  617. 0,
  618.  
  619. 16,
  620. 29,
  621. 0,
  622.  
  623. 17,
  624. 29,
  625. 0,
  626.  
  627. 26,
  628. 29,
  629. 0,
  630.  
  631. 10,
  632. 29,
  633. 0,
  634.  
  635. 12,
  636. 29,
  637. 0,
  638.  
  639. 11,
  640. 29,
  641. 0,
  642.  
  643. 2,
  644. 0,
  645.  
  646. 27,
  647. 0,
  648.  
  649. 28,
  650. 0,
  651.  
  652. 1,
  653. 0,
  654.  
  655. 22,
  656. 0,
  657.  
  658. 6,
  659. 0,
  660.  
  661. 21,
  662. 0,
  663.  
  664. 15,
  665. 0,
  666.  
  667. 25,
  668. 0,
  669.  
  670. 26,
  671. 0,
  672.  
  673. 23,
  674. 0,
  675.  
  676. 5,
  677. 0,
  678.  
  679. 4,
  680. 0,
  681.  
  682. 14,
  683. 0,
  684.  
  685. 13,
  686. 0,
  687. 0};
  688. # define YYTYPE char
  689. struct yywork { YYTYPE verify, advance; } yycrank[] = {
  690. 0,0,    0,0,    1,3,    0,0,    
  691. 0,0,    0,0,    0,0,    0,0,    
  692. 0,0,    0,0,    1,4,    1,5,    
  693. 0,0,    4,26,    0,0,    0,0,    
  694. 0,0,    0,0,    0,0,    0,0,    
  695. 0,0,    0,0,    0,0,    0,0,    
  696. 0,0,    0,0,    0,0,    0,0,    
  697. 0,0,    0,0,    0,0,    0,0,    
  698. 0,0,    0,0,    0,0,    1,6,    
  699. 4,26,    1,7,    1,8,    0,0,    
  700. 1,9,    1,10,    1,11,    0,0,    
  701. 9,29,    1,12,    1,13,    1,14,    
  702. 14,33,    1,15,    33,42,    29,0,    
  703. 9,29,    9,29,    29,30,    0,0,    
  704. 0,0,    0,0,    0,0,    1,16,    
  705. 1,17,    1,18,    16,35,    18,36,    
  706. 35,43,    0,0,    1,19,    1,19,    
  707. 0,0,    20,38,    0,0,    2,6,    
  708. 0,0,    0,0,    2,8,    0,0,    
  709. 2,9,    2,10,    2,11,    9,0,    
  710. 0,0,    2,12,    9,30,    2,14,    
  711. 0,0,    20,39,    0,0,    0,0,    
  712. 9,29,    0,0,    0,0,    9,29,    
  713. 1,20,    20,36,    1,21,    2,16,    
  714. 2,17,    2,18,    1,22,    1,22,    
  715. 8,27,    38,44,    39,45,    0,0,    
  716. 0,0,    0,0,    0,0,    13,31,    
  717. 9,29,    9,29,    13,32,    13,32,    
  718. 13,32,    13,32,    13,32,    13,32,    
  719. 13,32,    13,32,    13,32,    13,32,    
  720. 0,0,    30,41,    0,0,    0,0,    
  721. 1,23,    1,24,    1,25,    30,41,    
  722. 2,20,    0,0,    2,21,    0,0,    
  723. 8,28,    0,0,    0,0,    0,0,    
  724. 0,0,    0,0,    0,0,    0,0,    
  725. 9,29,    9,29,    15,34,    15,34,    
  726. 15,34,    15,34,    15,34,    15,34,    
  727. 15,34,    15,34,    15,34,    15,34,    
  728. 0,0,    30,41,    0,0,    0,0,    
  729. 0,0,    0,0,    0,0,    30,41,    
  730. 2,23,    2,24,    2,25,    19,37,    
  731. 0,0,    0,0,    19,37,    19,37,    
  732. 19,37,    19,37,    19,37,    19,37,    
  733. 19,37,    19,37,    19,37,    19,37,    
  734. 0,0,    0,0,    0,0,    0,0,    
  735. 0,0,    0,0,    0,0,    19,37,    
  736. 19,37,    19,37,    19,37,    19,37,    
  737. 19,37,    19,37,    19,37,    19,37,    
  738. 19,37,    19,37,    19,37,    19,37,    
  739. 19,37,    19,37,    19,37,    19,37,    
  740. 19,37,    19,37,    19,37,    19,37,    
  741. 19,37,    19,37,    19,37,    19,37,    
  742. 19,37,    0,0,    0,0,    0,0,    
  743. 0,0,    0,0,    0,0,    19,37,    
  744. 19,37,    19,37,    19,37,    19,37,    
  745. 19,37,    19,37,    19,37,    19,37,    
  746. 19,37,    19,37,    19,37,    19,37,    
  747. 19,37,    19,37,    19,37,    19,37,    
  748. 19,37,    19,37,    19,37,    19,37,    
  749. 19,37,    19,37,    19,37,    19,37,    
  750. 19,37,    22,40,    0,0,    0,0,    
  751. 22,40,    22,40,    22,40,    22,40,    
  752. 22,40,    22,40,    22,40,    22,40,    
  753. 22,40,    22,40,    0,0,    0,0,    
  754. 0,0,    0,0,    0,0,    0,0,    
  755. 0,0,    22,40,    22,40,    22,40,    
  756. 22,40,    22,40,    22,40,    22,40,    
  757. 22,40,    22,40,    22,40,    22,40,    
  758. 22,40,    22,40,    22,40,    22,40,    
  759. 22,40,    22,40,    22,40,    22,40,    
  760. 22,40,    22,40,    22,40,    22,40,    
  761. 22,40,    22,40,    22,40,    0,0,    
  762. 0,0,    0,0,    0,0,    0,0,    
  763. 0,0,    22,40,    22,40,    22,40,    
  764. 22,40,    22,40,    22,40,    22,40,    
  765. 22,40,    22,40,    22,40,    22,40,    
  766. 22,40,    22,40,    22,40,    22,40,    
  767. 22,40,    22,40,    22,40,    22,40,    
  768. 22,40,    22,40,    22,40,    22,40,    
  769. 22,40,    22,40,    22,40,    32,32,    
  770. 32,32,    32,32,    32,32,    32,32,    
  771. 32,32,    32,32,    32,32,    32,32,    
  772. 32,32,    0,0,    0,0,    0,0,    
  773. 0,0};
  774. struct yysvf yysvec[] = {
  775. 0,    0,    0,
  776. yycrank+-1,    0,        yyvstop+1,
  777. yycrank+-37,    yysvec+1,    yyvstop+3,
  778. yycrank+0,    0,        yyvstop+5,
  779. yycrank+4,    0,        yyvstop+7,
  780. yycrank+0,    0,        yyvstop+10,
  781. yycrank+0,    0,        yyvstop+12,
  782. yycrank+0,    0,        yyvstop+15,
  783. yycrank+9,    0,        yyvstop+18,
  784. yycrank+-43,    0,        yyvstop+20,
  785. yycrank+0,    0,        yyvstop+22,
  786. yycrank+0,    0,        yyvstop+25,
  787. yycrank+0,    0,        yyvstop+28,
  788. yycrank+62,    0,        yyvstop+31,
  789. yycrank+2,    0,        yyvstop+33,
  790. yycrank+94,    0,        yyvstop+36,
  791. yycrank+4,    0,        yyvstop+39,
  792. yycrank+0,    0,        yyvstop+41,
  793. yycrank+3,    0,        yyvstop+44,
  794. yycrank+118,    0,        yyvstop+47,
  795. yycrank+2,    0,        yyvstop+50,
  796. yycrank+0,    0,        yyvstop+53,
  797. yycrank+196,    0,        yyvstop+56,
  798. yycrank+0,    0,        yyvstop+59,
  799. yycrank+0,    0,        yyvstop+62,
  800. yycrank+0,    0,        yyvstop+65,
  801. yycrank+0,    yysvec+4,    yyvstop+68,
  802. yycrank+0,    0,        yyvstop+70,
  803. yycrank+0,    0,        yyvstop+72,
  804. yycrank+-15,    yysvec+9,    0,    
  805. yycrank+55,    0,        0,    
  806. yycrank+0,    0,        yyvstop+74,
  807. yycrank+271,    0,        yyvstop+76,
  808. yycrank+4,    0,        yyvstop+78,
  809. yycrank+0,    yysvec+15,    yyvstop+80,
  810. yycrank+3,    0,        0,    
  811. yycrank+0,    0,        yyvstop+82,
  812. yycrank+0,    yysvec+19,    yyvstop+84,
  813. yycrank+8,    0,        0,    
  814. yycrank+9,    0,        0,    
  815. yycrank+0,    yysvec+22,    yyvstop+86,
  816. yycrank+0,    0,        yyvstop+88,
  817. yycrank+0,    0,        yyvstop+90,
  818. yycrank+0,    0,        yyvstop+92,
  819. yycrank+0,    0,        yyvstop+94,
  820. yycrank+0,    0,        yyvstop+96,
  821. 0,    0,    0};
  822. struct yywork *yytop = yycrank+328;
  823. struct yysvf *yybgin = yysvec+1;
  824. char yymatch[] = {
  825. 00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  826. 01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
  827. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  828. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  829. 011 ,01  ,01  ,01  ,'$' ,01  ,01  ,'$' ,
  830. 01  ,01  ,01  ,01  ,01  ,'-' ,01  ,01  ,
  831. '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
  832. '0' ,'0' ,01  ,01  ,01  ,01  ,01  ,01  ,
  833. 01  ,'A' ,'B' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  834. 'B' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  835. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  836. 'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,01  ,
  837. 01  ,'a' ,'b' ,'a' ,'a' ,'a' ,'a' ,'a' ,
  838. 'b' ,'a' ,'a' ,'a' ,'a' ,'a' ,'a' ,'a' ,
  839. 'a' ,'a' ,'a' ,'a' ,'a' ,'a' ,'a' ,'a' ,
  840. 'a' ,'a' ,'a' ,01  ,01  ,01  ,01  ,01  ,
  841. 0};
  842. char yyextra[] = {
  843. 0,0,0,0,0,0,0,0,
  844. 0,0,0,0,0,0,0,0,
  845. 0,0,0,0,0,0,0,0,
  846. 0,0,0,0,0,0,0,0,
  847. 0};
  848. #ifndef lint
  849. static    char ncform_sccsid[] = "@(#)ncform 1.6 88/02/08 SMI"; /* from S5R2 1.2 */
  850. #endif
  851.  
  852. int yylineno =1;
  853. # define YYU(x) x
  854. # define NLSTATE yyprevious=YYNEWLINE
  855. char yytext[YYLMAX];
  856. struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  857. char yysbuf[YYLMAX];
  858. char *yysptr = yysbuf;
  859. int *yyfnd;
  860. extern struct yysvf *yyestate;
  861. int yyprevious = YYNEWLINE;
  862. yylook(){
  863.     register struct yysvf *yystate, **lsp;
  864.     register struct yywork *yyt;
  865.     struct yysvf *yyz;
  866.     int yych, yyfirst;
  867.     struct yywork *yyr;
  868. # ifdef LEXDEBUG
  869.     int debug;
  870. # endif
  871.     char *yylastch;
  872.     /* start off machines */
  873. # ifdef LEXDEBUG
  874.     debug = 0;
  875. # endif
  876.     yyfirst=1;
  877.     if (!yymorfg)
  878.         yylastch = yytext;
  879.     else {
  880.         yymorfg=0;
  881.         yylastch = yytext+yyleng;
  882.         }
  883.     for(;;){
  884.         lsp = yylstate;
  885.         yyestate = yystate = yybgin;
  886.         if (yyprevious==YYNEWLINE) yystate++;
  887.         for (;;){
  888. # ifdef LEXDEBUG
  889.             if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  890. # endif
  891.             yyt = yystate->yystoff;
  892.             if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
  893.                 yyz = yystate->yyother;
  894.                 if(yyz == 0)break;
  895.                 if(yyz->yystoff == yycrank)break;
  896.                 }
  897.             *yylastch++ = yych = input();
  898.             yyfirst=0;
  899.         tryagain:
  900. # ifdef LEXDEBUG
  901.             if(debug){
  902.                 fprintf(yyout,"char ");
  903.                 allprint(yych);
  904.                 putchar('\n');
  905.                 }
  906. # endif
  907.             yyr = yyt;
  908.             if ( (int)yyt > (int)yycrank){
  909.                 yyt = yyr + yych;
  910.                 if (yyt <= yytop && yyt->verify+yysvec == yystate){
  911.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  912.                         {unput(*--yylastch);break;}
  913.                     *lsp++ = yystate = yyt->advance+yysvec;
  914.                     goto contin;
  915.                     }
  916.                 }
  917. # ifdef YYOPTIM
  918.             else if((int)yyt < (int)yycrank) {        /* r < yycrank */
  919.                 yyt = yyr = yycrank+(yycrank-yyt);
  920. # ifdef LEXDEBUG
  921.                 if(debug)fprintf(yyout,"compressed state\n");
  922. # endif
  923.                 yyt = yyt + yych;
  924.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  925.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  926.                         {unput(*--yylastch);break;}
  927.                     *lsp++ = yystate = yyt->advance+yysvec;
  928.                     goto contin;
  929.                     }
  930.                 yyt = yyr + YYU(yymatch[yych]);
  931. # ifdef LEXDEBUG
  932.                 if(debug){
  933.                     fprintf(yyout,"try fall back character ");
  934.                     allprint(YYU(yymatch[yych]));
  935.                     putchar('\n');
  936.                     }
  937. # endif
  938.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  939.                     if(yyt->advance+yysvec == YYLERR)    /* error transition */
  940.                         {unput(*--yylastch);break;}
  941.                     *lsp++ = yystate = yyt->advance+yysvec;
  942.                     goto contin;
  943.                     }
  944.                 }
  945.             if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  946. # ifdef LEXDEBUG
  947.                 if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  948. # endif
  949.                 goto tryagain;
  950.                 }
  951. # endif
  952.             else
  953.                 {unput(*--yylastch);break;}
  954.         contin:
  955. # ifdef LEXDEBUG
  956.             if(debug){
  957.                 fprintf(yyout,"state %d char ",yystate-yysvec-1);
  958.                 allprint(yych);
  959.                 putchar('\n');
  960.                 }
  961. # endif
  962.             ;
  963.             }
  964. # ifdef LEXDEBUG
  965.         if(debug){
  966.             fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  967.             allprint(yych);
  968.             putchar('\n');
  969.             }
  970. # endif
  971.         while (lsp-- > yylstate){
  972.             *yylastch-- = 0;
  973.             if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  974.                 yyolsp = lsp;
  975.                 if(yyextra[*yyfnd]){        /* must backup */
  976.                     while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  977.                         lsp--;
  978.                         unput(*yylastch--);
  979.                         }
  980.                     }
  981.                 yyprevious = YYU(*yylastch);
  982.                 yylsp = lsp;
  983.                 yyleng = yylastch-yytext+1;
  984.                 yytext[yyleng] = 0;
  985. # ifdef LEXDEBUG
  986.                 if(debug){
  987.                     fprintf(yyout,"\nmatch ");
  988.                     sprint(yytext);
  989.                     fprintf(yyout," action %d\n",*yyfnd);
  990.                     }
  991. # endif
  992.                 return(*yyfnd++);
  993.                 }
  994.             unput(*yylastch);
  995.             }
  996.         if (yytext[0] == 0  /* && feof(yyin) */)
  997.             {
  998.             yysptr=yysbuf;
  999.             return(0);
  1000.             }
  1001.         yyprevious = yytext[0] = input();
  1002.         if (yyprevious>0)
  1003.             output(yyprevious);
  1004.         yylastch=yytext;
  1005. # ifdef LEXDEBUG
  1006.         if(debug)putchar('\n');
  1007. # endif
  1008.         }
  1009.     }
  1010. yyback(p, m)
  1011.     int *p;
  1012. {
  1013. if (p==0) return(0);
  1014. while (*p)
  1015.     {
  1016.     if (*p++ == m)
  1017.         return(1);
  1018.     }
  1019. return(0);
  1020. }
  1021.     /* the following are only used in the lex library */
  1022. yyinput(){
  1023.     return(input());
  1024.     }
  1025. yyoutput(c)
  1026.   int c; {
  1027.     output(c);
  1028.     }
  1029. yyunput(c)
  1030.    int c; {
  1031.     unput(c);
  1032.     }
  1033.